home *** CD-ROM | disk | FTP | other *** search
/ Aminet 25 / Aminet 25 (1998)(GTI - Schatztruhe)[!][Jun 1998].iso / Aminet / comm / net / amipx1_23.lha / amipx1_23 / Doc / fool_doom2.c < prev   
C/C++ Source or Header  |  1998-04-02  |  7KB  |  277 lines
  1. #include <clib/exec_protos.h>
  2. #include <amipx.h>
  3. #include <amipx_protos.h>
  4. #include <amipx_pragmas.h>
  5. #include <exec/tasks.h>
  6. #include <devices/timer.h>
  7. #include <dos/dos.h>
  8.  
  9. struct AMIPX_Library *AMIPX_Library;
  10.  
  11. struct myECB {
  12.  struct AMIPX_ECB ECB;
  13.  struct AMIPX_Fragment extra[2];
  14. };
  15.  
  16. unsigned char pd[12]={00,00,00,00,02,00,02,00,00,00,00,00
  17.                    };
  18.  
  19. /*****************************************************************************
  20.  * This program fools DOOM into thinking it found a second DOOM node in IPX  *
  21.  * game setup time.                                                          *
  22.  * All this program does is send the packet data above with a DOOM timeval   *
  23.  * -1, and listening for packets. It keeps doing this until sent a CTRL-C.   *
  24.  *****************************************************************************/
  25. struct Task *mytask;
  26. ULONG sendsigmask;
  27. ULONG listensigmask;
  28.  
  29. /* Aztec stuff to make a registerised function */
  30. void SendESR(BYTE,struct AMIPX_ECB *);
  31. #pragma regcall(SendESR(D0,A0))
  32. void SendESR(BYTE caller,struct AMIPX_ECB *ecb)
  33. {
  34.  /* simply wake up main */
  35.  geta4(); // essential!
  36.  
  37.  Signal(mytask,sendsigmask);
  38. }
  39.  
  40. /* Aztec stuff to make a registerised function */
  41. void ListenESR(BYTE,struct AMIPX_ECB *);
  42. #pragma regcall(ListenESR(D0,A0))
  43. void ListenESR(BYTE caller,struct AMIPX_ECB *ecb)
  44. {
  45.  /* simply wake up main */
  46.  geta4(); // essential!
  47.  
  48.  Signal(mytask,listensigmask);
  49. }
  50.  
  51. struct myECB LECB[4];
  52. struct AMIPX_PacketHeader Lheader[4];
  53. BYTE Ltime[4][4];
  54. BYTE Luserdata[4][512];
  55.  
  56. /* Aztec calls this function. default action is to exit the program */
  57. void _abort()
  58. {
  59. }
  60.  
  61. main(int argc,char **argv)
  62. {
  63.  struct myECB ECB;
  64.  unsigned char myaddrbuff[20];
  65.  int t,lp;
  66.  UWORD mysocket;
  67.  int socknum,sendsigbit,listensigbit;
  68.  ULONG sigret,timersigmask;
  69.  struct AMIPX_PacketHeader header;
  70.  BYTE time[4];
  71.  BYTE userdata[512];
  72.  int count;
  73.  int ecbindex;
  74.  int running,submitted_timerio;
  75.  struct timerequest *TimerIO;
  76.  struct MsgPort *TimerMP;
  77.  struct Message *TimerMSG;
  78.     
  79.  socknum=0x869b;
  80.  
  81.  mytask=FindTask(NULL);
  82.  
  83. /* allocate a signal to wake me up when an ecb has been processed */
  84.  sendsigbit=AllocSignal(-1);
  85.  if(sendsigbit==-1) {
  86.   printf("Cannot allocate signal!\n");
  87.   return 0;
  88.  }
  89.  listensigbit=AllocSignal(-1);
  90.  if(listensigbit==-1) {
  91.   FreeSignal(sendsigbit);
  92.   printf("Cannot allocate signal!\n");
  93.   return 0;
  94.  } 
  95.  sendsigmask = 1<<sendsigbit;
  96.  listensigmask = 1<<listensigbit;
  97.  
  98.  SetSignal(sendsigmask|listensigmask|timersigmask,0L);
  99.  
  100.  if(argc>1)
  101.   sscanf(argv[1],"%x",&socknum);
  102.  
  103.  for(lp=0;lp<4;lp++) { /* set up 4 listen requests */
  104.   for(t=0;t<sizeof(struct myECB);t++)
  105.    ((char *)&(LECB[lp]))[t]=0;
  106.  
  107.   LECB[lp].ECB.ESR=ListenESR;
  108.   LECB[lp].ECB.Fragment[0].FragData=&(Lheader[lp]);
  109.   LECB[lp].ECB.Fragment[0].FragSize=sizeof(struct AMIPX_PacketHeader);
  110.   LECB[lp].ECB.FragCount=3;
  111.   LECB[lp].ECB.Fragment[1].FragData=&(Ltime[lp]);
  112.   LECB[lp].ECB.Fragment[1].FragSize=4;
  113.   LECB[lp].ECB.Fragment[2].FragData=&(Luserdata[lp]);
  114.   LECB[lp].ECB.Fragment[2].FragSize=12;
  115.   LECB[lp].ECB.InUse=0x00;
  116.  }
  117.  
  118.  for(t=0;t<10;t++)
  119.   myaddrbuff[t]=10-t;
  120.  
  121.  for(t=0;t<4;t++)
  122.   time[t]=0xff;
  123.  
  124.  for(t=0;t<12;t++)
  125.   userdata[t]=pd[t];
  126.  
  127.  for(t=0;t<sizeof(ECB);t++)
  128.   ((char *)&ECB)[t]=0;
  129.  
  130.  header.Checksum=0xffff;
  131.  header.Length=0x2e;
  132.  header.Tc=0;
  133.  header.Type=0;
  134.  
  135.  ECB.ECB.ESR=SendESR;
  136.  ECB.ECB.Fragment[0].FragData=&header;
  137.  ECB.ECB.Fragment[0].FragSize=sizeof(header);
  138.  ECB.ECB.FragCount=3;
  139.  ECB.ECB.Fragment[1].FragData=&time;
  140.  ECB.ECB.Fragment[1].FragSize=4;
  141.  ECB.ECB.Fragment[2].FragData=&userdata;
  142.  ECB.ECB.Fragment[2].FragSize=12;
  143.  ECB.ECB.InUse=0x00;
  144.  for(t=0;t<6;t++)
  145.   ECB.ECB.ImmedAddr[t]=0xff;
  146.  
  147.  AMIPX_Library=(struct AMIPX_Library *)OpenLibrary("amipx.library",0);
  148.  
  149.  lp=0; // is first Listen that will be satisfied (at least in AMIPX it is)
  150.  submitted_timerio=0;
  151.  
  152.  if(AMIPX_Library) {
  153.   TimerMP = CreateMsgPort();
  154.   if(TimerMP) {
  155.    TimerIO=
  156.     (struct timerequest *)CreateIORequest(TimerMP,sizeof(struct timerequest));
  157.    if(TimerIO) {
  158.     if(OpenDevice((STRPTR)TIMERNAME,UNIT_VBLANK,(struct IORequest *)TimerIO,0L)){
  159.      DeleteIORequest((struct IORequest *)TimerIO);
  160.      TimerIO=NULL;
  161.      DeleteMsgPort(TimerMP);
  162.     }
  163.    }                                      
  164.   }
  165.   printf("Library opened.\n");
  166.   if(TimerIO) {
  167.    printf("Timer.device opened.\n");
  168.    AMIPX_GetLocalAddr(myaddrbuff);
  169.    for(t=0;t<10;t++)
  170.     printf("%02x ",(unsigned int)myaddrbuff[t]);
  171.    printf("\n");
  172.    if((mysocket=AMIPX_OpenSocket(socknum))!=0) {
  173.     printf("Socket %04x opened\n",(unsigned int)mysocket);
  174.     for(t=0;t<4;t++) {
  175.      header.Dst.Network[t]=0; // all directly connected networks
  176.     }
  177.  
  178.     for(t=0;t<6;t++) {
  179.      header.Dst.Node[t]=0xff;
  180.     }
  181.     timersigmask=1<<TimerMP->mp_SigBit;
  182.        
  183.     SetSignal(timersigmask,0L);
  184.        
  185.     header.Dst.Socket=mysocket;
  186.     ECB.ECB.Socket=mysocket;
  187.  
  188.     printf("Now submitting Listen ECBs...\n");
  189.  
  190.     for(lp=0;lp<4;lp++) {
  191.      LECB[lp].ECB.Socket=mysocket;
  192.  
  193.      AMIPX_ListenForPacket(&LECB[lp]);
  194.     }
  195.     printf("Now sending the first packet...\n");
  196.  
  197.     running=1;
  198.     lp=0;
  199.  
  200.     printf("Send: %d\n",AMIPX_SendPacket(&ECB));
  201.  
  202.     TimerIO->tr_time.tv_micro=0;
  203.     TimerIO->tr_time.tv_secs=1;      // sleep for max. 1 sec
  204.     TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  205.     SendIO((struct IORequest *) TimerIO);
  206.     submitted_timerio=1;
  207.  
  208.     while(running) {
  209.  
  210.      sigret=Wait(timersigmask|sendsigmask|listensigmask|SIGBREAKF_CTRL_C);
  211.      if(sigret & SIGBREAKF_CTRL_C) {
  212.       running=0;
  213.       printf("CTRL-C\n");
  214.      }
  215.      if(sigret & listensigmask) {
  216.       while(LECB[lp].ECB.InUse)
  217.        lp=(1+lp)%4;
  218.  
  219.       while(!LECB[lp].ECB.InUse) {
  220.        printf("Packet received.\n");
  221.        printf("header : ");
  222.        for(t=0;t<sizeof(header);t++)
  223.         printf("%02x ",((unsigned char *)&Lheader[lp])[t]);
  224.  
  225.        printf("\nTime : ");
  226.  
  227.        for(t=0;t<4;t++)
  228.         printf("%02x ",(unsigned char)Ltime[lp][t]);
  229.  
  230.        printf("\n");
  231.        for(t=0;t<512 && t<(Lheader[lp].Length-34);t++)
  232.         printf("%02x ",(unsigned char)Luserdata[lp][t]);
  233.  
  234.        printf("\n");
  235.        if(running) // no sense in submitting request if we have to quit anyway
  236.         AMIPX_ListenForPacket(&LECB[lp]);
  237.  
  238.        lp=(1+lp)%4;
  239.       }
  240.      }
  241.      if(running) {
  242.       if(sigret & sendsigmask) {
  243.        printf("Packet was transmitted OK.\n");
  244.       }
  245.       if(sigret & timersigmask) {
  246.        if(!ECB.ECB.InUse) {
  247.         printf("Send: %d\n",AMIPX_SendPacket(&ECB));
  248.        }
  249.        else {
  250.         printf("Send has not returned yet!!!\n");
  251.        }
  252.        TimerIO->tr_time.tv_micro=0;
  253.        TimerIO->tr_time.tv_secs=1;      // sleep for max. 1 sec
  254.        TimerIO->tr_node.io_Command = TR_ADDREQUEST;
  255.        SendIO((struct IORequest *) TimerIO);
  256.       }
  257.      }
  258.     }
  259.    }
  260.    if(submitted_timerio) { // in use 
  261.     AbortIO((struct IORequest *) TimerIO);
  262.     WaitIO((struct IORequest *) TimerIO);
  263.    }
  264.    AMIPX_CloseSocket(mysocket);
  265.    CloseDevice((struct IORequest *) TimerIO);
  266.    DeleteIORequest((struct IORequest *)TimerIO);
  267.   }
  268.   else {
  269.    printf("Panic! Socket not opened!\n");
  270.   }
  271.   FreeSignal(sendsigbit); // CLI will want this back
  272.   FreeSignal(listensigbit);
  273.   printf("Now exiting...\n");
  274.   CloseLibrary(AMIPX_Library);
  275.  }
  276. }
  277.